package main

import (
	"fmt"

	"ddl_checker/internal/parser"
	"ddl_checker/pkg/analyzer"
)

func main() {
	fmt.Println("=== HybridAnalyzer作为analyzer.SQLAnalyzer接口演示 ===")
	fmt.Println("展示HybridAnalyzer实现接口后的使用方式")
	fmt.Println()

	// 创建混合分析器
	hybridAnalyzer := parser.NewHybridAnalyzer()

	// 将HybridAnalyzer作为接口使用
	var analyzerInterface analyzer.SQLAnalyzer = hybridAnalyzer

	// 测试用例
	testCases := []struct {
		name string
		sql  string
	}{
		{
			name: "PostgreSQL语法CREATE TABLE",
			sql:  "CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100) NOT NULL);",
		},
		{
			name: "SELECT语句",
			sql:  "SELECT id, name FROM users WHERE age > 18;",
		},
		{
			name: "批量SQL语句",
			sql: `CREATE TABLE products (id INT PRIMARY KEY, name VARCHAR(100));
			INSERT INTO products (id, name) VALUES (1, 'Laptop');
			SELECT * FROM products;`,
		},
	}

	for i, tc := range testCases {
		fmt.Printf("=== 测试用例 %d: %s ===\n", i+1, tc.name)
		fmt.Printf("SQL: %s\n", tc.sql)
		fmt.Println()

		// 使用接口方法：ParseBatch
		fmt.Println("--- ParseBatch ---")
		statements, err := analyzerInterface.ParseBatch(tc.sql, ";")
		if err != nil {
			fmt.Printf("❌ 解析失败: %v\n", err)
		} else {
			fmt.Printf("✅ 解析成功，共 %d 条语句:\n", len(statements))
			for j, stmt := range statements {
				fmt.Printf("  语句%d: %s (语法: %v, 解析器: %s)\n",
					j+1, stmt.StatementType, stmt.IsValid, stmt.ParserUsed)
			}
		}
		fmt.Println()

		// 使用接口方法：ParseSingle（对于单条语句）
		if len(tc.sql) > 0 && tc.sql[len(tc.sql)-1] == ';' {
			singleSQL := tc.sql[:len(tc.sql)-1] // 移除分号
			fmt.Println("--- ParseSingle ---")
			statement, err := analyzerInterface.ParseSingle(singleSQL)
			if err != nil {
				fmt.Printf("❌ 单条解析失败: %v\n", err)
			} else if statement != nil {
				fmt.Printf("✅ 单条解析成功: %s (语法: %v, 解析器: %s)\n",
					statement.StatementType, statement.IsValid, statement.ParserUsed)
			}
			fmt.Println()
		}

		// 使用接口方法：ValidateSQL
		fmt.Println("--- ValidateSQL ---")
		valid, msg := analyzerInterface.ValidateSQL(tc.sql)
		if valid {
			fmt.Printf("✅ 语法正确: %s\n", msg)
		} else {
			fmt.Printf("❌ 语法错误: %s\n", msg)
		}
		fmt.Println()

		// 使用接口方法：SplitStatements
		fmt.Println("--- SplitStatements ---")
		splitStatements, err := analyzerInterface.SplitStatements(tc.sql, ";")
		if err != nil {
			fmt.Printf("❌ 分割失败: %v\n", err)
		} else {
			fmt.Printf("✅ 成功分割为 %d 条语句:\n", len(splitStatements))
			for k, stmt := range splitStatements {
				if len(stmt) > 50 {
					stmt = stmt[:50] + "..."
				}
				fmt.Printf("  %d. %s\n", k+1, stmt)
			}
		}

		fmt.Println("========================================")
		fmt.Println()
	}

	// 展示回退机制的详细信息
	fmt.Println("=== 回退机制测试 ===")

	// 测试可能触发回退的SQL语法
	fallbackTests := []struct {
		name string
		sql  string
	}{
		{
			name: "标准PostgreSQL语法",
			sql:  "SELECT generate_series(1, 5) as num;",
		},
		{
			name: "MySQL兼容语法",
			sql:  "SELECT * FROM users LIMIT 10 OFFSET 20;",
		},
	}

	for _, test := range fallbackTests {
		fmt.Printf("测试: %s\n", test.name)
		fmt.Printf("SQL: %s\n", test.sql)

		// 使用接口解析
		statements, err := analyzerInterface.ParseBatch(test.sql, ";")
		if err != nil {
			fmt.Printf("❌ 解析失败: %v\n", err)
		} else if len(statements) > 0 {
			fmt.Printf("✅ 解析成功，使用解析器: %s\n", statements[0].ParserUsed)
			fmt.Printf("   语句类型: %s, 语法正确: %v\n",
				statements[0].StatementType, statements[0].IsValid)
		}
		fmt.Println()
	}

	fmt.Println("=== 接口兼容性验证 ===")
	fmt.Println("✅ HybridAnalyzer成功实现了analyzer.SQLAnalyzer接口")
	fmt.Println("✅ 保持了与原有DDLStatement方法的向后兼容性")
	fmt.Println("✅ 支持作为接口使用，也支持原有功能")
}
